home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 1 / PC Actual CD 01.iso / f1 / cimb.arj / TECLAS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-03  |  16.6 KB  |  671 lines
  1. /*==============================================================================
  2.  
  3. FICHERO: TECLAS.C
  4.  
  5. AUTOR: ANTONIO LADESA JURADO
  6.  
  7. FECHA: 24/6/94
  8.  
  9. DESCRIPCION:
  10.  
  11.     Fichero que contiene las estructuras, constantes, variables y funciones
  12.     para el control de eventos y visualización de teclas,    textos y mensajes.
  13.  
  14. ==============================================================================*/
  15.  
  16.  
  17. /*---- MODULOS USADOS --------------------------------------------------------*/
  18.  
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21. #include <graphics.h>
  22. #include <ctype.h>
  23. #include <alloc.h>
  24. #include <string.h>
  25. #include <dir.h>
  26. #include <dos.h>
  27. #include <bios.h>
  28. #include <errno.h>
  29. #include <conio.h>
  30.  
  31. #include "global.h"
  32. #include "raton.h"
  33. #include "error.h"
  34. #include "teclas.h"
  35.  
  36. /*---- ESTRUCTURAS, CONSTANTES Y VARIABLES LOCALES AL MODULO -----------------*/
  37.  
  38.     /* estructura de acción */
  39. struct ACCION accion;
  40.     /* evento a leer */
  41. struct EVENTO evento;
  42.  
  43.     /* marcos de los menus */
  44. struct TECLA m[NUM_MARCOS] =
  45.     {
  46.             /* titulo */
  47.     {  0,  5,639, 30,OFF,""},
  48.         /* mensajes */
  49.     {  0,459,639, 20,OFF,""},
  50.         /* cuadro directorio */
  51.     {  0, 39,255,350,OFF,""},
  52.         /* cuadro menu impresion */
  53.     {260, 40,379,130,OFF,""},
  54.         /* cuadro menu memoria */
  55.     {260,170,379,54,OFF,""},
  56.         /* cuadro menu escalado */
  57.     {260,225,379,54,OFF,""},
  58.         /* cuadro menu blanco y negro */
  59.     {260,280,379,54,OFF,""},
  60.         /* cuadro confirmar */
  61.     {260,300,379,89,OFF,""},
  62.     };
  63.  
  64.     /* teclas */
  65. extern struct TECLA t[NUM_TECLAS]=
  66.     {
  67.         /* teclas de funcion */
  68.     {  0, 395, 79,30,OFF,"Cargar"},
  69.     { 80, 395, 79,30,OFF,"Ver"},
  70.     {160, 395, 79,30,OFF,"Salvar"},
  71.     {240, 395, 79,30,OFF,"Nuevo"},
  72.     {320, 395, 79,30,OFF,"Giro H."},
  73.     {400, 395, 79,30,OFF,"Giro V."},
  74.     {480, 395, 79,30,OFF,"B y N"},
  75.     {560, 395, 79,30,OFF,"Invertir"},
  76.     {  0, 425, 79,30,OFF,"Gris"},
  77.     { 80, 425, 79,30,OFF,"Colores"},
  78.     {160, 425, 79,30,OFF,"Imprimir"},
  79.     {240, 425, 79,30,OFF,"Vision"},
  80.     {320, 425, 79,30,OFF,"Memoria"},
  81.     {400, 425, 79,30,OFF,"Escalar"},
  82.     {480, 425, 79,30,OFF,"Informar"},
  83.     {560, 425, 79,30,OFF,"Salir"},
  84.         /* flechas directorio */
  85.     {125, 95,20,20,OFF," \030 "},
  86.     {125,335,20,20,OFF," \031 "},
  87.         /* unidades de disco */
  88.     {180,100,50,25,OFF,"A:\337\333\337"},
  89.     {180,130,50,25,OFF,"B:\337\333\337"},
  90.     {180,160,50,25,ON ,"C:\262\262\262"},
  91.         /* formatos graficos */
  92.     {156,215,90,15,OFF,"MAC"},
  93.     {156,230,90,15,ON ,"PCX"},
  94.     {156,245,90,15,OFF,"GIF"},
  95.     {156,260,90,15,OFF,"TIFF"},
  96.     {156,275,90,15,OFF,"IMG"},
  97.     {156,290,90,15,OFF,"TGA"},
  98.     {156,305,90,15,OFF,"BMP"},
  99.  
  100.         /* teclas de ficheros */
  101.     { 40,360,80,20,OFF,"Borrar"},
  102.     {140,360,80,20,OFF,"Renombrar"},
  103.  
  104.         /* teclas del menu de escalado */
  105.     {350,250,20,20,OFF," \030 "},
  106.     {410,250,20,20,OFF," \031 "},
  107.     {440,250,20,20,OFF," \030 "},
  108.     {500,250,20,20,OFF," \031 "},
  109.     {530,240,95,30,OFF,"ACEPTAR"},
  110.  
  111.         /* teclas del menu de memoria */
  112.     {265,190,120,30,ON ,"Extendida(XMS)"},
  113.     {390,190,120,30,OFF,"Expandida(EMS)"},
  114.     {515,190,115,30,OFF,"Virtual (VMS)"},
  115.  
  116.         /* teclas del menu de impresion */
  117.     {545,100,80,30,OFF ,"IMPRIMIR"},
  118.     {275, 85,120,30,ON ,"Epson FX 80"},
  119.     {275,120,120,30,OFF,"PostScript"},
  120.     {410, 85,120,30,OFF,"Fichero"},
  121.     {410,120,120,30,ON ,"Impresora"},
  122.  
  123.         /* teclas del menu de Blanco y Negro */
  124.     {290,300, 70,30,ON ,"BAYER"},
  125.     {370,300, 70,30,OFF,"FLOYD"},
  126.     {450,300, 70,30,OFF,"STUCKI"},
  127.     {530,300, 70,30,OFF,"BURKES"},
  128.  
  129.         /* teclas del menu de confirmar */
  130.     {460,350,80,25,OFF,"CANCELAR"},
  131.     {550,350,80,25,ON ,"ACEPTAR"},
  132.     };
  133.  
  134. /*---- DEFINICION DE LAS FUNCIONES INTERNAS ----------------------------------*/
  135.  
  136. void Cuadro(struct TECLA *t);
  137. void Interior(struct TECLA *t,int color);
  138. int leetecla(void);
  139.  
  140. /*---- CODIFICACION DE LAS FUNCIONES OFRECIDAS -------------------------------*/
  141.  
  142. /*---- FUNCION: extern void TECLAponer(struct TECLA *t) ------------------------
  143.  
  144.     Descripción:
  145.  
  146.         Esta función dibuja una tecla. Si está activa, la dibuja resaltada.
  147.  
  148.     Parámetros:
  149.  
  150.         Puntero a la estructura de la tecla.
  151.  
  152. ---- CODIGO: -----------------------------------------------------------------*/
  153.  
  154. extern void TECLAponer(struct TECLA *t)
  155. {
  156.     /* dibujar cuadro */
  157. Cuadro(t);
  158.     /* dibujar interior */
  159. if(t->e)
  160.     Interior(t,c7);
  161. else
  162.     Interior(t,c3);
  163. }
  164.  
  165. /*---- FIN FUNCION -----------------------------------------------------------*/
  166.  
  167. /*---- FUNCION: extern void TECLAresaltar(struct TECLA *t) ---------------------
  168.  
  169.     Descripción:
  170.  
  171.         Esta función resalta tecla.
  172.  
  173.     Parámetros:
  174.  
  175.         Puntero a la estructura de la tecla.
  176.  
  177. ---- CODIGO: -----------------------------------------------------------------*/
  178.  
  179. extern void TECLAresaltar(struct TECLA *t)
  180. {
  181.  /* dibuja interior resaltado */
  182. Interior(t,c7);
  183.     /* espera */
  184. delay(100);
  185.     /* dibuja interior */
  186. Interior(t,c3);
  187. }
  188.  
  189. /*---- FIN FUNCION -----------------------------------------------------------*/
  190.  
  191. /*---- FUNCION: extern void TECLAactivar(struct TECLA *t) ----------------------
  192.  
  193.     Descripción:
  194.  
  195.         Esta función activa una tecla. Cambia su estado a activo y la dibuja
  196.         resaltada.
  197.  
  198.     Parámetros:
  199.  
  200.         Puntero a la estructura de la tecla.
  201.  
  202. ---- CODIGO: -----------------------------------------------------------------*/
  203.  
  204. extern void TECLAactivar(struct TECLA *t)
  205. {
  206.     /* si no está activa */
  207. if(!t->e)
  208.     {
  209.         /* activar y dibujar resaltada */
  210.     t->e = ON;Interior(t,c7);
  211.     }
  212. }
  213.  
  214. /*---- FIN FUNCION -----------------------------------------------------------*/
  215.  
  216. /*---- FUNCION: extern void TECLAdesactivar(struct TECLA *t) -------------------
  217.  
  218.     Descripción:
  219.  
  220.         Esta función desactiva una tecla. Cambia su estado a inactivo y la dibuja.
  221.  
  222.     Parámetros:
  223.  
  224.         Puntero a la estructura de la tecla.
  225.  
  226. ---- CODIGO: -----------------------------------------------------------------*/
  227.  
  228. extern void TECLAdesactivar(struct TECLA *t)
  229. {
  230.     /* si está activa */
  231. if(t->e)
  232.     {
  233.         /* desactivar y dibujar */
  234.     t->e = OFF;Interior(t,c3);
  235.     }
  236. }
  237.  
  238. /*---- FIN FUNCION -----------------------------------------------------------*/
  239.  
  240. /*---- FUNCION: extern void MENSAJEponer(int x,int y,int ancho,char *texto)-----
  241.  
  242.     Descripción:
  243.  
  244.         Esta función escribe un mensaje sobre un rectángulo. Si el mensaje es
  245.         mayor que el rectángulo, escribe la parte final.
  246.  
  247.     Parámetros:
  248.  
  249.         int x: coordenada izquierda del rectángulo
  250.         int y: coordenada superior del rectángulo
  251.         int ancho: ancho en pixels del rectángulo
  252.         char *texto: texto a escribir
  253.  
  254. ---- CODIGO: -----------------------------------------------------------------*/
  255.  
  256. extern void MENSAJEponer(int x,int y,int ancho,char *texto)
  257. {
  258.     /* número máximo de caracteres */
  259. int maximo;
  260.  
  261.     /* calcular máximo de caracteres */
  262. maximo = (ancho-5)/8;
  263.     /* dibujar rectángulo */
  264. setcolor(c4);
  265. setfillstyle(SOLID_FILL,c4);
  266. bar(x,y,x+ancho-1,y+14);
  267. setcolor(c1);
  268.     /* escribir texto */
  269. if(strlen(texto) > maximo)
  270.     outtextxy(x+5,y+3,texto+strlen(texto)-maximo);
  271. else
  272.     outtextxy(x+5,y+3,texto);
  273. }
  274.  
  275. /*---- FIN FUNCION -----------------------------------------------------------*/
  276.  
  277. /*---- FUNCION: extern void ESTADOponer(char *texto) ---------------------------
  278.  
  279.     Descripción:
  280.  
  281.         Esta función escribe un texto en la línea de estado
  282.  
  283.     Parámetros:
  284.  
  285.         char *texto: texto a escribir
  286.  
  287. ---- CODIGO: -----------------------------------------------------------------*/
  288.  
  289. extern void ESTADOponer(char *texto)
  290. {
  291.     /* dibujar rectángulo */
  292. setcolor(c4);
  293. setfillstyle(SOLID_FILL,c4);
  294. bar(m[1].x+5,m[1].y+5,m[1].x+m[1].ancho-5,m[1].y+m[1].alto-5);
  295. setcolor(c1);
  296.     /* escribir texto */
  297. outtextxy(m[1].x+10,m[1].y+5,texto);
  298. }
  299.  
  300. /*---- FIN FUNCION -----------------------------------------------------------*/
  301.  
  302. /*---- FUNCION: extern void ESTADOquitar(void) ---------------------------------
  303.  
  304.     Descripción:
  305.  
  306.         Esta función limpia la línea de estado
  307.  
  308. ---- CODIGO: -----------------------------------------------------------------*/
  309.  
  310. extern void ESTADOquitar(void)
  311. {
  312. TECLAponer(&m[1]);
  313. }
  314.  
  315. /*---- FIN FUNCION -----------------------------------------------------------*/
  316.  
  317. /*---- FUNCION: extern void TEXTOponer(int x,int y,char *texto)-----------------
  318.  
  319.     Descripción:
  320.  
  321.         Esta función escribe un texto sobre el fondo actual
  322.  
  323.     Parámetros:
  324.  
  325.         int x: coordenada izquierda del texto
  326.         int y: coordenada superior del texto
  327.         char *texto: texto a escribir
  328.  
  329. ---- CODIGO: -----------------------------------------------------------------*/
  330.  
  331. extern void TEXTOponer(int x,int y,char *texto)
  332. {
  333. setcolor(c2);
  334. outtextxy(x+1,y,texto);
  335. }
  336.  
  337. /*---- FIN FUNCION -----------------------------------------------------------*/
  338.  
  339. /*---- FUNCION: extern void TEXTOresaltar(int x,int y,int ancho,char *texto) ---
  340.  
  341.     Descripción:
  342.  
  343.         Esta función escribe un texto, resaltándolo sobre un rectángulo.
  344.  
  345.     Parámetros:
  346.  
  347.         int x: coordenada izquierda del rectángulo
  348.         int y: coordenada superior del rectángulo
  349.         int ancho: ancho en pixels del rectángulo
  350.         char *texto: texto a escribir
  351.  
  352. ---- CODIGO: -----------------------------------------------------------------*/
  353.  
  354. extern void TEXTOresaltar(int x,int y,int ancho,char *texto)
  355. {
  356. setcolor(c2);
  357. setfillstyle(SOLID_FILL,c2);
  358. bar(x,y-2,x+ancho-1,y+10);
  359. setcolor(c1);
  360. outtextxy(x+1,y,texto);
  361. }
  362.  
  363. /*---- FIN FUNCION -----------------------------------------------------------*/
  364.  
  365. /*---- FUNCION: extern char *LeerCadena(int x,int y,int ancho,char *cad) -------
  366.  
  367.     Descripción:
  368.  
  369.         Esta función lee una cadena desde el dispositivo de entrada.
  370.  
  371.     Parámetros:
  372.  
  373.         int x: coordenada izquierda del rectángulo de lectura
  374.         int y: coordenada superior del rectángulo de lactura
  375.         int ancho: ancho en pixels del rectángulo de lectura
  376.         char *cad: cadena a leer
  377.  
  378. ---- CODIGO: -----------------------------------------------------------------*/
  379.  
  380. extern char *LeerCadena(int x,int y,int ancho,char *cad)
  381. {
  382.     /* contador de caracteres */
  383. int j=0;
  384.     /* buffer de lectura */
  385. char p[128];
  386.     /* copia de la cadena anterior */
  387. char copia[128];
  388. /* máximo de caracteres */
  389. int longitud;
  390.  
  391.     /* guardar copia */
  392. strcpy(copia,cad);
  393.  
  394.     /* leer longitud máxima de caracteres visibles */
  395. longitud = ancho/8-1;
  396.     /* leer longitud de la cadena */
  397. j=strlen(cad);
  398.     /* escribir cadena visible y cursor */
  399. if(j <=(longitud-2))
  400.     {
  401.     strcpy(p,cad);p[j]='_';p[j+1]=0;
  402.     }
  403. else
  404.     {
  405.     strcpy(p,&cad[j-(longitud-2)]);p[longitud-2]='_';p[longitud-1]=0;
  406.     }
  407. MENSAJEponer(x,y,ancho,p);
  408.  
  409. while(1)
  410.     {
  411.         /* leer tecla o pulsación de ratón */
  412.     evento = leer_evento(evento);
  413.     switch(evento.e)
  414.         {
  415.             /* si no evento, seguir */
  416.         case NO_EVENTO:break;
  417.             /* si botón derecho o ESCAPE salir y devolver sin cambiar */
  418.         case RATON_DCHO_ON:
  419.         case ESC:MENSAJEponer(x,y,ancho,copia);return(copia);
  420.             /* si botón izquierdo o INTRO, devolver cambiada */
  421.         case RATON_IZDO_ON:
  422.         case RET:MENSAJEponer(x,y,ancho,cad);return(cad);
  423.             /* si backspace, borrar caracter anterior */
  424.         case DEL:if(j>0)cad[--j]=0;break;
  425.             /* en otro caso */
  426.         default:
  427.                 /* si es un carácter imprimible, añadirlo a la cadena */
  428.             if(isprint(evento.e) && !isspace(evento.e))
  429.                 if(j<(MAXPATH-1))
  430.                     {
  431.                     cad[j++] = evento.e;cad[j]=0;
  432.                     }
  433.         break;
  434.         }
  435.  
  436.         /* pintar cadena actual y cursor */
  437.     if(j <=(longitud-2))
  438.         {
  439.         strcpy(p,cad);p[j]='_';p[j+1]=0;
  440.         }
  441.     else
  442.         {
  443.         strcpy(p,&cad[j-(longitud-2)]);p[longitud-2]='_';p[longitud-1]=0;
  444.         }
  445.     MENSAJEponer(x,y,ancho,p);
  446.     }
  447. }
  448.  
  449. /*---- FIN FUNCION -----------------------------------------------------------*/
  450.  
  451. /*---- FUNCION: extern struct EVENTO leer_evento(struct EVENTO evento) ---------
  452.  
  453.     Descripción:
  454.  
  455.         Esta función devuelve un evento leido. Se entiende por evento, una
  456.         pulsación de una tecla o botón del ratón.
  457.  
  458.     Parámetros:
  459.  
  460.         struct EVENTO evento: evento a leer
  461.  
  462.     Retorno:
  463.  
  464.         evento leido
  465.  
  466. ---- CODIGO: -----------------------------------------------------------------*/
  467.  
  468. extern struct EVENTO leer_evento(struct EVENTO evento)
  469. {
  470.     /* inicializa evento */
  471. evento.e = NO_EVENTO;
  472.     /* leer hasta que se produzca el evento */
  473. for(;evento.e==NO_EVENTO;)
  474.     {
  475.         /* retardo */
  476.     delay(100);
  477.         /* testear si se ha pulsado una tecla */
  478.     evento.e = bioskey(1);
  479.         /* si se pulsó, leerla */
  480.     if(evento.e != 0)
  481.         {
  482.             /* el evento es el código de la tecla */
  483.         evento.e = leetecla();
  484.         switch(evento.e)
  485.             {
  486.                 /* si es una tecla usada por el programa, terminar */
  487.             case ARRIBA:
  488.             case ABAJO:
  489.             case IZQ:
  490.             case DER:
  491.             case ORIGEN:
  492.             case FIN:
  493.             case PGARR:
  494.             case PGABJ:
  495.             case BORRAR:
  496.             case INSERT:
  497.             case ESC:
  498.             case DEL:
  499.             case RET:break;
  500.  
  501.                 /* si no es usada por el programa, devolver no evento */
  502.             case F1: case F2: case F3: case F4: case F5:
  503.             case F6: case F7: case F8: case F9: case F10:
  504.             default:
  505.                 if(!isprint((char)evento.e))
  506.                     evento.e = NO_EVENTO;
  507.             break;
  508.             };
  509.         }
  510.     else
  511.             /* comprobar si se pulsó botón del raton */
  512.         if(!(evento.e = RATONestadoPulsar(RATON_IZDO,&(evento.x),&(evento.y))))
  513.             evento.e = RATONestadoPulsar(RATON_DCHO,&(evento.x),&(evento.y));
  514.     }
  515.     /* devolver evento */
  516. return(evento);
  517. }
  518.  
  519. /*---- FIN FUNCION -----------------------------------------------------------*/
  520.  
  521. /*---- FUNCION: extern int TestTecla(int x,int y) ------------------------------
  522.  
  523.     Descripción:
  524.  
  525.         Esta función detecta si las coordenadas x,y se encuentran dentro de un
  526.         area o tecla.
  527.  
  528.     Parámetros:
  529.  
  530.         int x: coordenada x
  531.         int y: coordenada y
  532.  
  533.     Retorno:
  534.  
  535.         Si corresponden a una tecla, devuelve su número (definido en OPCIONES)
  536.         Si corresponden a un area, devuelve su opción (definido en OPCIONES)
  537.         Si no corresponden a ninguno, devuelve  NOOPC
  538.  
  539. ---- CODIGO: -----------------------------------------------------------------*/
  540.  
  541. extern int TestTecla(int x,int y)
  542. {
  543. int i;
  544.  
  545. if(x<0)
  546.     return(NOOPC);
  547.     /* comprobar si están dentro de una tecla */
  548. for(i=0;i<NUM_TECLAS;i++)
  549.     {
  550.     if(    (y >= t[i].y) &&
  551.             (y < t[i].y+t[i].alto) &&
  552.             (x >= t[i].x) &&
  553.             (x < t[i].x+t[i].ancho)
  554.         )
  555.         return(i);
  556.     }
  557.     /* comprobar areas sensibles del menu */
  558.     /* lista de ficheros y directorios */
  559. if((x > 15) && (x < 125) && (y > 95) && (y < 349))
  560.     return(OPlista);
  561.     /* fichero de acción principal */
  562. if((x > 17) && (x < 241) && (y > 61) && (y < 77))
  563.     return(OPfichero);
  564.     /* lectura de cadena en el menu de confirmar */
  565. if((x > 270) && (x < 430) && (y > 360) && (y < 376))
  566.     return(OPficheroDOS);
  567.  
  568. return(NOOPC);
  569. }
  570.  
  571. /*---- FIN FUNCION -----------------------------------------------------------*/
  572.  
  573. /*---- CODIFICACION DE LAS FUNCIONES INTERNAS --------------------------------*/
  574.  
  575. /*---- FUNCION: void Cuadro(struct TECLA *t) -----------------------------------
  576.  
  577.     Descripción:
  578.  
  579.         Esta función dibuja el borde exterior de una tecla
  580.  
  581.     Parámetros:
  582.  
  583.         struct TECLA *t: puntero a la tecla
  584.  
  585. ---- CODIGO: -----------------------------------------------------------------*/
  586.  
  587. void Cuadro(struct TECLA *t)
  588. {
  589. int register l,a,b = 3;
  590. a = t->ancho-1;
  591. l = t->alto-1;
  592.  
  593. setcolor(c1);
  594. moveto(t->x,t->y);
  595. linerel(a,0);linerel(-b,b);
  596. linerel(-(a-2*b),0);linerel(0,l-2*b);
  597. linerel(-b,b);linerel(0,-l);
  598. setfillstyle(SOLID_FILL,c1);
  599. floodfill(t->x+1,t->y+1,c1);
  600.  
  601. setcolor(c4);
  602. moveto(t->x+a,t->y);
  603. linerel(0,l);linerel(-a,0);
  604. linerel(b,-b);linerel(a-2*b,0);
  605. linerel(0,-(l-2*b));linerel(b,-b);
  606. setfillstyle(SOLID_FILL,c4);
  607. floodfill(t->x+a-1,t->y+l-1,c4);
  608. }
  609.  
  610. /*---- FIN FUNCION -----------------------------------------------------------*/
  611.  
  612. /*---- FUNCION: void Interior(struct TECLA *t,int color) -----------------------
  613.  
  614.     Descripción:
  615.  
  616.         Esta función dibuja el interior de una tecla con un color dado
  617.  
  618.     Parámetros:
  619.  
  620.         struct TECLA *t: puntero a la tecla
  621.         int color: color de la tecla
  622.  
  623. ---- CODIGO: -----------------------------------------------------------------*/
  624.  
  625. void Interior(struct TECLA *t,int color)
  626. {
  627. int register l,a,b = 3;
  628. a = t->ancho-1;
  629. l = t->alto-1;
  630.  
  631. setcolor(color);
  632. setfillstyle(SOLID_FILL,color);
  633. bar(t->x+b,t->y+b,t->x+(a-b),t->y+l-b);
  634.  
  635. setcolor(c2);
  636. setfillstyle(SOLID_FILL,c2);
  637. outtextxy(t->x+(a-textwidth(t->texto))/2,t->y+(l-8)/2,t->texto);
  638. }
  639.  
  640. /*---- FIN FUNCION -----------------------------------------------------------*/
  641.  
  642. /*---- FUNCION: int leetecla(void) ---------------------------------------------
  643.  
  644.     Descripción:
  645.  
  646.         Esta función lee una tecla del teclado.
  647.  
  648.     Retorno:
  649.  
  650.         - Si la tecla es normal (código ASCII), la devuelve como tal,
  651.         con un valor menor a 256.
  652.         - Si es una tecla especial, el código supera 256.
  653. ---- CODIGO: -----------------------------------------------------------------*/
  654.  
  655. int leetecla(void)
  656. {
  657. int tecla,baja,alta,salida;
  658.  
  659.     /* leer tecla */
  660. tecla = bioskey(0);
  661.     /* guardar código ASCII */
  662. baja = tecla & 0x00ff;
  663.     /* guardar tecla especial */
  664. alta = (tecla & 0xff00) >> 8;
  665.     /* devolver ASCII o especial */
  666. salida = ((baja==0) ? alta+256:baja);
  667. return(salida);
  668. }
  669.  
  670. /*---- FIN FUNCION -----------------------------------------------------------*/
  671.